Sprite 1984 - 1993/Sprite 1984 - 1993.iso/src/lib/jaq/dist/dev.c.metrum

Text File | 1992-10-26 | 13.5 KB | 680 lines

/*
 * dev.c--
 *
 *    Device-dependent manipulations for Metrum RSS-600
 *
 * Copyright 1991 Regents of the University of California
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies.  The University of California
 * makes no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without
 * express or implied warranty.
 *
 * Quote:
 *      "What a depressingly stupid machine"
 *      -- Marvin in _A Hitchiker's Guide to the Galaxy_
 *
 */

#ifndef lint
static char rcsid[] = "$Header: /sprite/lib/forms/RCS/dev.c,v 1.0 91/01/07 18:02:37 mottsmth Exp $ SPRITE (Berkeley)";
#endif /* not lint */

#include <stdio.h>
#include <sys/types.h>
#include <sys/mtio.h>
#include "jaquith.h"
#include "asaca.h"

typedef struct mtop Dev_TapeCommand;

static char printBuf[T_MAXSTRINGLEN];
extern int syserr;


/*
 *----------------------------------------------------------------------
 *
 * Dev_MoveVolume --
 *
 *    Move a volume from source slot to destination slot in jukebox
 *
 * Results:
 *    Ptr to block of specified size or NULL;
 *
 * Side effects:
 *    Moves robot arm. May also affect volume reader.
 *
 * Note:
 *      The tape reader devices in the Metrum RSS-600 jukebox are given slot
 *      numbers 604-609. If one of these is the destination address
 *      a tape load is effectively done.
 *
 *----------------------------------------------------------------------
 */

int
Dev_MoveVolume(robotStream, src, dest)
    int robotStream;          /* robot file descriptor */
    int src;                  /* source location */
    int dest;                 /* destination location */
{
    struct ascmd asacaCmd;

    int cmdType;
    asacaCmd.as_src = src;
    asacaCmd.as_dest = dest;
    asacaCmd.as_mode = 0;
    asacaCmd.as_barcode[0] = '\0';

    if (isvlds(src)) {
    if (isvlds(dest)) {
        cmdType = ASIOCMOVE1;
    } else {
        asacaCmd.as_src = dest; /* Don't ask me, ask Metrum */
        asacaCmd.as_dest = src;
        cmdType = ASIOCSTORE1;
    }
    } else {
    if (isvlds(dest)) {
        cmdType = ASIOCLOAD1;
    } else {
        cmdType = ASIOCMOVE2;
    }
    }
    if (asaca_ioctl(robotStream, cmdType, &asacaCmd) != 0) {
    syserr = errno;
    return T_ROBOTFAILED;
    } else {
        return T_SUCCESS;
    }

}


/*
 *----------------------------------------------------------------------
 *
 * Dev_OpenVolume --
 *
 *    Open the device
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_OpenVolume(devName, flags)
    char *devName;            /* name of device */
    int flags;                /* read, write etc. flags */
{
    int fd;

    if ((fd=open(devName, flags, 0)) == -1) {
    syserr = errno;
    }
    return fd;
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_CloseVolume --
 *
 *    Close the device
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_CloseVolume(stream)
    int stream;               /* file descriptor */
{
    if (close(stream) == -1) {
    syserr = errno;
    return T_FAILURE;
    } else {
    return T_SUCCESS;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_ReadVolume --
 *
 *    Perform read operation on volume.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_ReadVolume(volStream, buf, bufSize)
    int volStream;
    char *buf;
    int bufSize;
{
    int cnt;

    if ((cnt=read(volStream, buf, bufSize)) < 0) {
    syserr = errno;
    }
    return cnt;
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_WriteVolume --
 *
 *    Perform write operation on volume.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_WriteVolume(volStream, buf, bufSize)
    int volStream;
    char *buf;
    int bufSize;
{
    int cnt;

    if ((cnt=write(volStream, buf, bufSize)) < 0) {
    syserr = errno;
    }
    return cnt;
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_UnloadVolume --
 *
 *    Open the pod bay door. I'm sorry I can't do that Dave.
 *
 * * Results:
 *    return code
 *
 * Side effects:
 *    Rewinds and unloads tape. Moves robot arm.
 *
 *----------------------------------------------------------------------
 */

int
Dev_UnloadVolume(devName)
    char *devName;            /* device name */
{
    int volStream;
    Dev_TapeCommand tapeCmd;

    if ((volStream=open(devName, O_RDONLY, 0)) < 0) {
    syserr = errno;
    return T_FAILURE;
    }

    tapeCmd.mt_op = MTOFFL;
    tapeCmd.mt_count = 1;

    if (ioctl(volStream, MTIOCTOP, (char *)&tapeCmd) != 0) {
    syserr = errno;
        close(volStream);
    return T_FAILURE;
    }
    close(volStream);

    return T_SUCCESS;

}

/*
 *----------------------------------------------------------------------
 *
 * Dev_InitRobot --
 *
 *    Initialize robot.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Instructs robot to build database of volume id's
 *      using barcode reader.
 *
 * Note:
 *      No tape inventory at the moment.
 *
 *----------------------------------------------------------------------
 */

int
Dev_InitRobot(robotName, robotStreamPtr)
    char *robotName;          /* robot device name */
    int *robotStreamPtr;      /* robot descriptor */
{
    if ((*robotStreamPtr=asaca_open(robotName)) == 0) {
    syserr = errno;
    return T_FAILURE;
    } else {
    return T_SUCCESS;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_ReadVolLabel --
 *
 *    Read volume label with barcode reader
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Instructs robot to return element status from its database.
 *
 * Note:
 *      Must adjust label conversion hack for local environment
 *
 *----------------------------------------------------------------------
 */

int
Dev_ReadVolLabel(robotStream, location, volLabel, volIdPtr)
    int robotStream;          /* robot descriptor */
    int location;             /* home slot in jukebox */
    char *volLabel;           /* receiving space for volume label */
    int *volIdPtr;            /* receiving space for converted label */
{
    struct ascmd asacaCmd;

    asacaCmd.as_src = location;
    asacaCmd.as_dest = 0;
    asacaCmd.as_mode = 0;
    asacaCmd.as_barcode[0] = '\0';

    if (asaca_ioctl(robotStream, ASIOCBCREAD2, &asacaCmd) != 0) {
    syserr = errno;
    return T_ROBOTFAILED;
    } else {
    strcpy(volLabel, asacaCmd.as_barcode);
    *volIdPtr = Dev_CvtVolLabel(volLabel);
        return T_SUCCESS;
    }

}


/*
 *----------------------------------------------------------------------
 *
 * Dev_CvtVolLabel --
 *
 *    Convert character volume label to unique integer.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 * Note:
 *      For present purposes, labels are of the form "<text><number>"
 *
 *----------------------------------------------------------------------
 */

int
Dev_CvtVolLabel(volLabel)
    char *volLabel;
{
    int volId;
    char *workPtr = volLabel+strlen(volLabel)-1;

    while ((workPtr >= volLabel) && (isdigit(*workPtr))) {
    workPtr--;
    }
    if ((workPtr >= volLabel) && (sscanf(workPtr+1, "%d", &volId) == 1)) {
    return volId;
    } else {
    return -1;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_SeekVolume --
 *
 *    Seek to file marker
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Instructs tape to seek
 *
 *----------------------------------------------------------------------
 */

int
Dev_SeekVolume(volStream, blkId, absolute)
    int volStream;            /* volume descriptor */
    int blkId;                /* logical file num */
    int absolute;             /* absolute positioning flag */
{
    int status;
    Dev_TapeCommand tapeCmd;
    int oldOffset = 0;
    int retryCnt = 0;

    if ((blkId < 0) || (blkId > 10000)) {
    fprintf(stderr,"Dev_SeekVolume: Bad blkId: %d\n", blkId);
    }

    if ((volStream < 0) || (volStream > 20)) {
    fprintf(stderr,"Dev_SeekVolume: Bad volStream: %d\n", volStream);
    }

    if (absolute) {
    tapeCmd.mt_op = MTREW;
    tapeCmd.mt_count = 1;
    status = ioctl(volStream, MTIOCTOP, (char *)&tapeCmd);
    while ((retryCnt++ < 5) && (status != 0)) {
        fprintf(stderr, "Rewind failed: errno %d. Retrying...\n",
            errno);
        sleep(2);
        status = ioctl(volStream, MTIOCTOP, (char *)&tapeCmd);
    }
    if (status != 0) {
        syserr = errno;
        fprintf(stderr, "Couldn't rewind tape. errno %d\n",syserr);
        return T_IOFAILED;
    }
    }

    if (blkId > 0) {
    tapeCmd.mt_op = MTFSF;
    tapeCmd.mt_count = blkId;
    status = ioctl(volStream, MTIOCTOP, (char *)&tapeCmd);
    if (status != 0) {
        syserr = errno;
        fprintf(stderr, "Couldn't skip %d files: %d\n",
            blkId, syserr);
        return T_IOFAILED;
    }
    }

    return T_SUCCESS;
}



/*
 *----------------------------------------------------------------------
 *
 * Dev_WriteEOF --
 *
 *    write out EOF
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Puts file marker on tape
 *
 *----------------------------------------------------------------------
 */

int
Dev_WriteEOF(volStream, count)
    int volStream;            /* active stream */
    int count;                /* number of marks to write */
{
    int status;
    Dev_TapeCommand tapeCmd;

    tapeCmd.mt_op = MTWEOF;
    tapeCmd.mt_count = count;

    status = ioctl(volStream, MTIOCTOP, (char *)&tapeCmd);

    if (status == 0) {
    return T_SUCCESS;
    } else {
    syserr = errno;
    return T_IOFAILED;
    }
}



/*
 *----------------------------------------------------------------------
 *
 * Dev_GetVolStatus --
 *
 *    Inquire into state of volume device
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_GetVolStatus(volStream, volStatusPtr)
    int volStream;            /* volume descriptor */
    VolStatus *volStatusPtr;  /* receiving structure */
{

    volStatusPtr->position = -1;
    return T_SUCCESS;
}

/*
 *----------------------------------------------------------------------
 *
 * Dev_DisplayMsg --
 *
 *    Display message on jukebox screen
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_DisplayMsg(robotStream, msg, msgStyle)
    int robotStream;          /* volume descriptor */
    char *msg;                /* Message text */
    int msgStyle;             /* 0==Steady, 1==flash, 2==scroll */
{

    return T_SUCCESS;

}

/*
 *----------------------------------------------------------------------
 *
 * Dev_OpenDoor --
 *
 *    Open (or at least unlock) the jukebox door.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

int
Dev_OpenDoor(robotStream)
    int robotStream;          /* robot descriptor */
{
    struct ascmd asacaCmd;

    asacaCmd.as_src = 0;
    asacaCmd.as_dest = 0;
    asacaCmd.as_mode = 0;
    asacaCmd.as_barcode[0] = '\0';

    if (asaca_ioctl(robotStream, ASIOCDOOROPEN, &asacaCmd) != 0) {
    syserr = errno;
    return T_ROBOTFAILED;
    } else {
        return T_SUCCESS;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Dev_RemoveVolume --
 *
 *    Open (or at least unlock) the jukebox door.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Kicks a volume out of archive.
 *
 *----------------------------------------------------------------------
 */

int
Dev_RemoveVolume(robotStream, src)
    int robotStream;          /* robot descriptor */
    int src;                  /* src slot location */
{
    /* the best we can do on a metrum is open the door. */
    return Dev_OpenDoor(robotStream);

}


/*
 *----------------------------------------------------------------------
 *
 * Dev_InsertVolume --
 *
 *    Open (or at least unlock) the jukebox door.
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    Pull in a new volume.
 *
 *----------------------------------------------------------------------
 */

int
Dev_InsertVolume(robotStream, dest)
    int robotStream;          /* robot descriptor */
    int dest;                 /* destination slot location */
{
    /* the best we can do on a metrum is open the door. */
    return Dev_OpenDoor(robotStream);

}


/*
 *----------------------------------------------------------------------
 *
 * Dev_BuildVolList --
 *
 *    Build a list of jukebox's contents
 *
 * Results:
 *    return code
 *
 * Side effects:
 *    none.
 *
 *----------------------------------------------------------------------
 */

int
Dev_BuildVolList(robotStream, listPtr, cntPtr)
    int robotStream;          /* robot descriptor */
    VolConfig *listPtr;       /* space for volume info */
    int *cntPtr;              /* size of list */

{
    int i;
    int cnt = 0;
    int maxBin = AS_MAXBIN+1;
    int retCode = T_SUCCESS;
    char label[T_MAXLABELLEN];

    if (*cntPtr < maxBin) {
    syserr = ENOSPC;
    *cntPtr = AS_MAXBIN+1;
    return T_FAILURE;
    }

    for (i=0; i<maxBin; i++) {
    if ((retCode=Dev_ReadVolLabel(robotStream, i, label)) != T_SUCCESS) {
        *cntPtr = 0;
        return retCode;
    }
    if (strcmp(label, "*************") != 0) {
        listPtr->volId = i;
        listPtr->location = i;
        strcpy(listPtr->volLabel, label);
        listPtr++;
        cnt++;
    }
    }

    *cntPtr = cnt;
    return T_SUCCESS;

}